/**
 * 封装的HTTP请求工具 - 自动加载axios
 */

(function () {
    // 检查API_CONFIG是否已定义
    if (typeof API_CONFIG === 'undefined') {
        console.error('❌ API_CONFIG未定义！请检查js文件加载顺序');
        throw new Error('API_CONFIG未定义，请确保api.js在http.js之前引入');
    }

    // 1. 检查是否已加载axios
    if (typeof axios !== 'undefined') {
        initHttp();
        return;
    }

    // 2. 动态加载axios
    var script = document.createElement('script');
    script.src = '/js/lib/axios.min.js';
    script.onload = initHttp;
    script.onerror = function () {
        console.error('加载axios失败！');
        if (typeof layui !== 'undefined') {
            layui.layer.msg('加载网络组件失败', { icon: 2 });
        }
    };
    document.head.appendChild(script);

    // 3. 初始化HTTP工具
    function initHttp() {
        // 定义后端支持的根路径列表
        // const BASE_PATHS = ['/pms/', '/admin/']; // 可根据需要添加更多路径
        const BASE_PATHS = [API_CONFIG.BASE_URL, API_CONFIG.ADMIN.BASE_URL];
        const ERROR_PATH = '/error/invalid-path'; // 错误提示路径

        // 检查URL是否匹配任何已定义的根路径
        function isBackendRequest(url) {
            return BASE_PATHS.some(path => url.startsWith(path));
        }

        // 基础配置
        axios.defaults.timeout = 30000;
        // axios.defaults.withCredentials = true; // 跨域请求携带cookie

        // 请求拦截器
        axios.interceptors.request.use(function (config) {
            // 排除静态资源请求
            if (config.url.includes('/js/') || config.url.includes('/templates/') || config.url.endsWith('.js')) {
                return config;
            }

            // 处理后端请求
            if (isBackendRequest(config.url)) {
                const token = localStorage.getItem('token');
                if (token) {
                    config.headers.Authorization = `Bearer ${token}`;
                }
                return config;
            } else {
                console.error(`无效的后端请求路径: ${config.url}`);
                // 重定向到错误路径
                config.url = ERROR_PATH;
                config.params = { originalUrl: config.url }; // 可选：将原始URL作为参数传递
                return config;
            }
        }, function (error) {
            return Promise.reject(error);
        });

        // 响应拦截器
        axios.interceptors.response.use(function (response) {
            // 检查是否是二进制响应（文件下载）
            const contentType = response.headers['content-type'];
            const isBlobResponse = contentType && (
                contentType.includes('application/pdf') ||
                contentType.includes('application/octet-stream') ||
                contentType.includes('application/vnd.ms-excel') ||
                contentType.includes('image/') ||
                response.config.responseType === 'blob'
            );

            // 如果是二进制响应，返回完整的 response 对象
            if (isBlobResponse) {
                return response;
            }

            // 确保 response.data 存在
            if (!response.data) {
                console.warn('响应数据为空，返回默认结构');
                return {
                    code: 200,
                    data: null,
                    msg: '请求成功'
                };
            }

            // 如果是JSON响应且有code字段，按原有逻辑处理
            if (response.data.code === 0 || response.data.code === 200) {
                return response.data;
            }

            console.log("Promise.reject(response.data);", response.data);
            return Promise.reject(response.data);
        }, function (error) {
            console.error('HTTP请求错误:', error);

            // 改进的错误处理
            let errorMessage = '网络连接失败';

            if (error.response) {
                // 服务器返回了错误状态码
                console.log('错误响应状态:', error.response.status);
                console.log('错误响应数据:', error.response.data);

                // 处理不同的错误状态码
                switch (error.response.status) {
                    case 401:
                        errorMessage = '登录已过期，请重新登录';
                        // 清除token
                        localStorage.removeItem('token');
                        localStorage.removeItem('user');
                        localStorage.removeItem('session');
                        break;
                    case 403:
                        errorMessage = '权限不足';
                        break;
                    case 404:
                        errorMessage = '请求的资源不存在';
                        break;
                    case 500:
                        errorMessage = '服务器内部错误';
                        break;
                    default:
                        errorMessage = `请求失败: ${error.response.status}`;
                }

                // 如果后端返回了结构化的错误信息
                if (error.response.data && typeof error.response.data === 'object') {
                    return Promise.reject(error.response.data);
                } else if (error.response.data) {
                    return Promise.reject({
                        msg: error.response.data.message || error.response.data.msg || errorMessage,
                        code: error.response.status
                    });
                }
            } else if (error.request) {
                // 请求已发送但没有收到响应
                console.error('无响应:', error.request);
                errorMessage = '网络连接失败，请检查网络';
            } else {
                // 其他错误
                console.error('请求配置错误:', error.message);
                errorMessage = error.message || '请求配置错误';
            }

            return Promise.reject({ msg: errorMessage, error: error });
        });

        // 封装HTTP方法
        var http = {
            get: function (url, params, config = {}) {
                return axios.get(url, { ...config, params });
            },
            post: function (url, data, config = {}) {
                return axios.post(url, data, config);
            },
            put: function (url, data, config = {}) {
                return axios.put(url, data, config);
            },
            delete: function (url, config = {}) {
                return axios.delete(url, config);
            },
            download: function (url, data, filename) {
                // 专门的文件下载方法
                return this.post(url, data, {
                    responseType: 'blob',
                    timeout: 60000 // 下载超时时间更长
                }).then(response => {
                    const contentDisposition = response.headers.get('Content-Disposition');

                    if (contentDisposition) {
                        const filenameMatch = contentDisposition.match(/filename="?(.+)"?/);
                        if (filenameMatch && filenameMatch[1]) {
                            filename = filenameMatch[1];
                            console.log('文件名:', filenameMatch[0]);
                        }
                    }
                    const blob = new Blob([response.data], { type: response.headers['content-type'] });
                    const downloadUrl = window.URL.createObjectURL(blob);
                    const link = document.createElement('a');
                    link.href = downloadUrl;
                    link.download = filename || `download_${Date.now()}`;
                    document.body.appendChild(link);
                    link.click();
                    document.body.removeChild(link);
                    window.URL.revokeObjectURL(downloadUrl);
                    return response;
                });
            },
            logout: function () {
                // 清除本地存储的token
                localStorage.removeItem('token');
                localStorage.removeItem('user');
                localStorage.removeItem('session');


                // 清除cookie（如果有）
                document.cookie = 'jwt_token=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';

                // 发送登出请求到后端
                return this.post(API_CONFIG.ENDPOINTS.LOGOUT)
                    .catch(err => {
                        // 即使后端登出失败，也继续前端清理
                        console.error('登出请求失败:', err);
                        return Promise.resolve();
                    });
            }
        };


        // 自定义$.ajax方法（保持不变）
        if (typeof layui !== 'undefined' && layui.$) {
            layui.$.ajax = function (options) {
                const method = (options.type || 'GET').toLowerCase();
                return http[method](options.url, options.data)
                    .then(function (response) {
                        if (typeof options.success === 'function') {
                            options.success(response);
                        }
                        return response;
                    })
                    .catch(function (error) {
                        if (typeof options.error === 'function') {
                            options.error({
                                status: error.response?.status,
                                responseJSON: error.response?.data,
                                statusText: error.message
                            });
                        }
                        throw error;
                    });
            };
        }

        // 暴露接口
        window.http = http;
    }
})();